home *** CD-ROM | disk | FTP | other *** search
/ Compendium Deluxe 2 / LSD and 17bit Compendium Deluxe - Volume II.iso / a / prog / misc / flexcat1_4.lha / flexcat / lib / C_c_V20.sd < prev    next >
Text File  |  1994-10-21  |  6KB  |  220 lines
  1. ##stringtype C
  2. ##shortstrings
  3. /****************************************************************
  4.    This file was created automatically by `FlexCat V1.4'
  5.    from "%f0.ct".
  6.  
  7.    Do NOT edit by hand!
  8. ****************************************************************/
  9.  
  10. #include <string.h>
  11.  
  12. #include <exec/memory.h>
  13. #include <libraries/iffparse.h>
  14.  
  15. #include <clib/iffparse_protos.h>
  16. #include <clib/locale_protos.h>
  17. #include <clib/dos_protos.h>
  18. #include <clib/exec_protos.h>
  19. #include <clib/utility_protos.h>
  20.  
  21. #ifdef AZTEC_C
  22. #include <pragmas/locale_lib.h>
  23. #include <pragmas/iffparse_lib.h>
  24. #include <pragmas/dos_lib.h>
  25. #include <pragmas/exec_lib.h>
  26. #include <pragmas/utility_lib.h>
  27. #endif    /*  AZTEC_C            */
  28.  
  29. #if defined(__SASC)  ||  defined(_DCC)  ||  defined(__MAXON__)
  30. #include <pragmas/locale_pragmas.h>
  31. #include <pragmas/iffparse_pragmas.h>
  32. #include <pragmas/dos_pragmas.h>
  33. #include <pragmas/exec_pragmas.h>
  34. #include <pragmas/utility_pragmas.h>
  35. #endif    /*  __SASC  ||    _DCC  ||  __MAXON__ */
  36.  
  37. #ifdef __GNUC__
  38. #include <inline/locale.h>
  39. #include <inline/iffparse.h>
  40. #include <inline/dos.h>
  41. #include <inline/exec.h>
  42. #include <inline/utility.h>
  43. #endif    /*  __GNUC__    */
  44.  
  45.  
  46. extern struct Library *UtilityBase;
  47. extern struct DosLibrary *DOSBase;
  48. extern struct ExecBase *SysBase;
  49.  
  50.  
  51.  
  52.  
  53. static LONG %b_Version = %v;
  54. static const STRPTR %b_BuiltInLanguage = (STRPTR) %l;
  55.  
  56. struct FC_Type
  57. {   LONG    ID;
  58.     STRPTR  Str;
  59. };
  60.  
  61. const struct FC_Type _%i = { %d, %s };
  62.  
  63. static struct Catalog *%b_Catalog = NULL;
  64. static struct FC_Type *%b_OwnCatalog = NULL;
  65. static LONG %b_OwnStrings;
  66. static LONG %b_OwnBytes;
  67.  
  68. void Open%bCatalog(struct Locale *loc, STRPTR language)
  69. { LONG tag, tagarg;
  70.   extern struct Library *LocaleBase;
  71.   extern struct Library *IFFParseBase;
  72.   extern void Close%bCatalog(void);
  73.  
  74.   Close%bCatalog();  /*  Not needed if the programmer pairs Open-()
  75.              and CloseCatalog() right, but does no harm. */
  76.   if (language == NULL)
  77.   { tag = TAG_IGNORE;
  78.   }
  79.   else
  80.   { tag = OC_Language;
  81.     tagarg = (LONG) language;
  82.   }
  83.   if (LocaleBase != NULL  &&  %b_Catalog == NULL)
  84.   { %b_Catalog = OpenCatalog(loc, (STRPTR) "%b.catalog",
  85.                  OC_BuiltInLanguage, %b_BuiltInLanguage,
  86.                  tag, tagarg,
  87.                  OC_Version, %b_Version,
  88.                  TAG_DONE);
  89.   }
  90.   if (LocaleBase == NULL  &&  IFFParseBase != NULL  &&  language != NULL  &&
  91.       Stricmp(language, %b_BuiltInLanguage) != 0)
  92.   { struct IFFHandle *iffhandle;
  93.     char path[128]; /*    Enough to hold 4 path items (dos.library 3.0)  */
  94.  
  95.     if ((iffhandle = AllocIFF())  !=  NULL)
  96.     { /*  Trying to open the catalog  */
  97.       strcpy(path, "Catalogs");
  98.       AddPart((STRPTR) path, language, sizeof(path));
  99.       AddPart((STRPTR) path, (STRPTR) "%b.catalog", sizeof(path));
  100.       if ((iffhandle->iff_Stream = Open((STRPTR) path, MODE_OLDFILE))
  101.                  ==  NULL)
  102.       { strcpy(path, "Locale:Catalogs");
  103.     AddPart((STRPTR) path, language, sizeof(path));
  104.     AddPart((STRPTR) path, (STRPTR) "%b.catalog", sizeof(path));
  105.     iffhandle->iff_Stream = Open((STRPTR) path, MODE_OLDFILE);
  106.       }
  107.  
  108.       if (iffhandle->iff_Stream)
  109.       { InitIFFasDOS(iffhandle);
  110.     if (!OpenIFF(iffhandle, IFFF_READ))
  111.     { if (!PropChunk(iffhandle, MAKE_ID('C','T','L','G'),
  112.              MAKE_ID('S','T','R','S')))
  113.       { struct StoredProperty *sp;
  114.         int error;
  115.  
  116.         for (;;)
  117.         { if ((error = ParseIFF(iffhandle, IFFPARSE_STEP))
  118.              ==  IFFERR_EOC)
  119.           { continue;
  120.           }
  121.           if (error != 0)
  122.           { break;
  123.           }
  124.  
  125.           if (sp = FindProp(iffhandle, MAKE_ID('C','T','L','G'),
  126.                 MAKE_ID('S','T','R','S')))
  127.           { LONG *ptr;
  128.         LONG BytesToScan, StrLength;
  129.  
  130.         /*  First scan: Check the number of strings        */
  131.         /*  Note that this assumes that the strings are padded    */
  132.         /*  to a longword boundary!                */
  133.         %b_OwnBytes = 0;
  134.         %b_OwnStrings = 0;
  135.         BytesToScan = sp->sp_Size;
  136.         ptr = sp->sp_Data;
  137.         while (BytesToScan > 0)
  138.         { ++%b_OwnStrings;
  139.           ++ptr;              /*  Skip ID        */
  140.           StrLength = *ptr+1;          /*  NUL-Byte!        */
  141.           %b_OwnBytes += StrLength;
  142.           ptr += 1+(StrLength+3)/4;   /*  Skip Length and String*/
  143.           BytesToScan -= 8+((StrLength+3)/4)*4;
  144.         }
  145.  
  146.         /*  Marginal check: BytesToScan has to be 0!        */
  147.         if (BytesToScan == 0)
  148.         { char *cptr;
  149.           LONG i;
  150.  
  151.           if (%b_OwnCatalog = (struct FC_Type *)
  152.               AllocMem(%b_OwnStrings*sizeof(struct FC_Type)+%b_OwnBytes,
  153.                    MEMF_ANY))
  154.           { /*    Second scan: Copy the strings and their ID's    */
  155.             cptr = (char *) &%b_OwnCatalog[%b_OwnStrings];
  156.             BytesToScan = sp->sp_Size;
  157.             ptr = sp->sp_Data;
  158.             i = 0;
  159.             while (BytesToScan > 0)
  160.             { %b_OwnCatalog[i].ID = *(ptr++);
  161.               %b_OwnCatalog[i].Str = (STRPTR) cptr;
  162.               StrLength = *ptr+1;     /*  NUL-Byte!        */
  163.               ptr++;
  164.               strncpy(cptr, (char *) ptr, StrLength);
  165.                     /*  Not more, not less bytes!    */
  166.               cptr+=StrLength;
  167.               ptr += (StrLength+3)/4;
  168.               BytesToScan -= 8+((StrLength+3)/4)*4;
  169.               ++i;
  170.             }
  171.             break;
  172.           }
  173.         }
  174.           }
  175.         }
  176.       }
  177.       CloseIFF(iffhandle);
  178.     }
  179.     Close(iffhandle->iff_Stream);
  180.       }
  181.  
  182.       FreeIFF(iffhandle);
  183.     }
  184.   }
  185. }
  186.  
  187.  
  188. void Close%bCatalog(void)
  189. { if (LocaleBase != NULL)
  190.   { CloseCatalog(%b_Catalog);
  191.   }
  192.   %b_Catalog = NULL;
  193.   if (%b_OwnCatalog != NULL)
  194.   { FreeMem(%b_OwnCatalog,
  195.         %b_OwnStrings*sizeof(struct FC_Type)+%b_OwnBytes);
  196.     %b_OwnCatalog = NULL;
  197.   }
  198. }
  199.  
  200.  
  201. STRPTR Get%bString(APTR fcstr)
  202. { STRPTR defaultstr = NULL;
  203.   LONG strnum, i;
  204.  
  205.   strnum = ((struct FC_Type *) fcstr)->ID;
  206.   defaultstr = ((struct FC_Type *) fcstr)->Str;
  207.  
  208.   if (%b_Catalog == NULL)
  209.   { if (%b_OwnCatalog != NULL)
  210.     { for (i = 0;  i < %b_OwnStrings;  i++)
  211.        { if (%b_OwnCatalog[i].ID == strnum)
  212.      { return(%b_OwnCatalog[i].Str);
  213.      }
  214.        }
  215.     }
  216.     return(defaultstr);
  217.   }
  218.   return(GetCatalogStr(%b_Catalog, strnum, defaultstr));
  219. }
  220.